//毫秒转化成 yyyy-mm-dd hh.ss.mm格式
export const timeStampToStr = (value: string) => {
  const date = new Date(value);
  const [year, month, day, hour, minute, second] = [
    date.getFullYear(),
    (date.getMonth() + 1 + "").padStart(2, "0"),
    (date.getDate() + "").padStart(2, "0"),
    (date.getHours() + "").padStart(2, "0"),
    (date.getMinutes() + "").padStart(2, "0"),
    (date.getSeconds() + "").padStart(2, "0"),
  ];
  return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
};

/**
 * 格式化日期
 * @param {Date|String} date 日期或日期字符串
 */
export const formatDate = (date: any) => {
  let YYYY = null;
  let M = null;
  let MM = null;
  let D = null;
  let DD = null;
  let h = null;
  let hh = null;
  let m = null;
  let mm = null;
  let s = null;
  let ss = null;
  let ms = null;
  let ms2 = null;
  let ms3 = null;
  let ms4 = null;
  // date = date ? new Date(date.replace(/-/g,"/")) : new Date()
  date = date ? date : new Date();

  // 如果 date 是 String 类型
  if (date && isString(date)) {
    // 真机运行时，如果直接用 new Date('YYYY-MM-DD hh:mm:ss') 会报 Invalid Date 错误，所以采用下面的方式创建日期
    const dtArr = date
      .replace(/\//g, ".")
      .replace(/-/g, ".")
      .replace(/:/g, ".")
      .replace(/T/g, " ")
      .replace(" ", ".")
      .replace("Z", "")
      .split(".");

    let year = 2020;
    let month = 12;
    let day = 18;
    let hour = 0;
    let minute = 0;
    let second = 0;
    let millisecond = 0;
    // 年
    if (dtArr.length > 0 && !isNaN(dtArr[0])) {
      year = parseInt(dtArr[0]);
    }
    // 月
    if (dtArr.length > 1 && !isNaN(dtArr[1])) {
      month = parseInt(dtArr[1]);
    }
    // 日
    if (dtArr.length > 2 && !isNaN(dtArr[2])) {
      day = parseInt(dtArr[2]);
    }
    // 时
    if (dtArr.length > 3 && !isNaN(dtArr[3])) {
      hour = parseInt(dtArr[3]);
    }
    // 分
    if (dtArr.length > 4 && !isNaN(dtArr[4])) {
      minute = parseInt(dtArr[4]);
    }
    // 秒
    if (dtArr.length > 5 && !isNaN(dtArr[5])) {
      second = parseInt(dtArr[5]);
    }
    // 毫秒
    if (dtArr.length > 6 && !isNaN(dtArr[6])) {
      millisecond = parseInt(dtArr[6]);
    }

    date = new Date(year, month - 1, day, hour, minute, second, millisecond);
  }

  // 如果 date 是 Date 类型
  if (date && isDate(date)) {
    YYYY = date.getFullYear();
    M = date.getMonth() + 1;
    MM = M >= 10 ? M : "0" + M;
    D = date.getDate();
    DD = D >= 10 ? D : "0" + D;
    h = date.getHours();
    hh = h >= 10 ? h : "0" + h;
    m = date.getMinutes();
    mm = m >= 10 ? m : "0" + m;
    s = date.getSeconds();
    ss = s >= 10 ? s : "0" + s;
    ms = date.getMilliseconds();
    ms2 = ms;
    ms3 = ms;
    ms4 = ms;
    if (ms < 10) {
      ms2 = "0" + ms;
      ms3 = "00" + ms;
      ms4 = "000" + ms;
    } else if (ms < 100) {
      ms3 = "0" + ms;
      ms4 = "00" + ms;
    } else {
      ms4 = "0" + ms;
    }
  }

  // 返回的数据对象
  const result = {
    YYYY: YYYY,
    MM: MM,
    M: M,
    DD: DD,
    D: D,
    hh: hh,
    h: h,
    mm: mm,
    m: m,
    ss: ss,
    s: s,
    ms: ms,
    ms2: ms2,
    ms3: ms3,
    ms4: ms4,
    dt: date,
    fmt1: `${YYYY}-${MM}-${DD}`,
    fmt2: `${YYYY}年${M}月${D}日`,
    fmt3: `${YYYY}-${M}-${D} ${hh}:${mm}`,
    fmt4: `${h}:${m}:${s}`,
    fmt5: `${MM}-${DD}`,
    fmt6: `${YYYY}-${MM}`,
    fmt7: `${YYYY}年${M}月`,
    fmt8: `${h}:${m}`,
    fmt9: `${M}月${D}日`,
    fmt10: `${YYYY}.${MM}.${DD}`,
    fmt11: `${hh}:${mm}`,
    fmt12: `${hh}:${mm}:${ss}`,
    fmt13: `${YYYY}-${M}-${D} ${hh}:${mm}:${ss}`,
    fmt14: `${YYYY}/${MM}/${DD}`,
    fmt15: `${YYYY}-${MM}-${DD} ${hh}:${mm}:${ss}`,
    fmt16: `${YYYY}-${M}-${D}`,
    fmt17: `${YYYY}-${MM}-${DD} ${hh}:${mm}`,
    fmt18: `${YYYY}-${MM}-${DD} 00:00:00`,
    fmt19: `${YYYY}-${MM}-${DD} 23:59:59`,
    fmt20: `${YYYY}-${MM}-01`,
    notes:
      "YYYY（年），MM（月，补0），M（月，不补0），DD（日，补0），D（日，不补0），hh（时，补0），h（时，不补0），mm（分，补0），m（分，不补0），ss（秒，补0），s（秒，不补0），ms（毫秒，不补0），ms2（毫秒，补0到2位），ms3（毫秒，补0到3位），ms4（毫秒，补0到4位），其余的fmt1，fmt2，... 看格式就知道了！",
  };

  /**
   * 判断数据是否是 String 类型
   * @param {Any} val 要判断的数据
   * @returns {Boolean} true：是；false：不是；
   */
  function isString(val: string) {
    return Object.prototype.toString.call(val) === "[object String]";
  }

  /**
   * 精确判断数据是否是 Date 类型
   * @param {Any} val 要判断的数据
   * @returns {Boolean} true：是；false：不是；
   */
  function isDate(val: any) {
    return Object.prototype.toString.call(val) === "[object Date]";
  }
  return result;
};

// 当月最后一天 即每月多少天
export const getMonthLastDay = (year: number, month: number) => {
  return new Date(year, month, 0).getDate();
};

// 根据当前 获取最后一天日期
export const getYearLastDay = (time: string, timeType: string) => {
  // 假设开始日期为start_date
  const start_date = new Date(time);
  // 获取该日期所在的年份、月份
  const year = start_date.getFullYear();
  const month = start_date.getMonth();
  // 构建下一年的一月一日的日期
  const next_year = new Date(year + 1, 0, 1);
  const next_month = new Date(year, month + 1, 1);

  let nowGetTime: any;
  if (timeType == "YEAR") {
    nowGetTime = next_year.getTime();
  } else if (timeType == "MONTH") {
    nowGetTime = next_month.getTime();
  } else if (timeType == "DAY") {
    nowGetTime = next_month.getTime();
  }
  // 减去一天，即为当前年份的最后一天的日期
  const last_day = new Date(nowGetTime - 24 * 60 * 60 * 1000);
  // 格式化日期为字符串
  return formatDate(last_day).fmt19;
};

// 这一天星期几 0-6（星期日到星期六）
export const getDayForWeek = (str: string) => {
  return new Date(str).getDay();
};

// 筛选出前一天
export const pickerOptions = (date: Date) => {
  return date.getTime() < new Date().getTime() - 86400000;
};

// 处理带T 8:00时间
export const filterDateT = (value: string) => {
  if (value) {
    const arr = value.split("T");
    const year = arr[0];
    const time = arr[1].split("+")[0];
    return year + " " + time;
  }
};

// 分钟转化成多少小时多少分钟
export const filterHourMinute = (minutes: number) => {
  if (minutes) {
    return Math.floor(minutes / 60) + "小时" + (minutes % 60) + "分";
  }
};

// 检测时间是否过期
export const checkTimeValidity = (time: Date) => {
  const date = new Date(time);
  return date.getTime() < Date.now();
};

// 日期去掉时间
export const dateSplitTime = (time: string) => {
  return time.split(" ")[0];
};

// 计算两个日期差多少天
export const diffDay = (lastDate: string, earlyDate: string) => {
  return (Date.parse(lastDate) - Date.parse(earlyDate)) / 1000 / 60 / 60 / 24;
};

// 禁用开始时间选择
export const pickerOptionsStart = (time: Date, endTime: Date) => {
  if (endTime) {
    return time.getTime() > new Date(endTime).getTime();
  }
};
// 禁用结束时间选择
export const pickerOptionsEnd = (time: Date, startTime: Date) => {
  if (startTime) {
    return Date.parse(formatDate(time).fmt19) < new Date(startTime).getTime();
  }
};
